/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package csp;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

/**
 *
 * @author Leandro
 */
public class Experimentador {

    public void generarExperimentacion(int cantProblemasPorN){

        int indiceColumnasCompletos=1;

        //Exportación a excel
        //libro completo
        HSSFWorkbook libro=new HSSFWorkbook();
        //Pagina de promedios
        HSSFSheet hojaPromedios = libro.createSheet("Promedios");
        HSSFRow filaEncabezadoPromedios = hojaPromedios.createRow(0);
        HSSFCell celdaEncabezadoProm=filaEncabezadoPromedios.createCell(0);
        celdaEncabezadoProm.setCellValue("Algortimo/Problema");
        //Creo las filas de los datos
        HSSFRow filaFCRuntimePromedios = hojaPromedios.createRow(1);
        HSSFCell celdaEtiquetaFCRruntimeProm=filaFCRuntimePromedios.createCell(0);
        celdaEtiquetaFCRruntimeProm.setCellValue("FCMVR-VMR:Runtime[ms]");

        HSSFRow filaFCRuntimeNSPromedios = hojaPromedios.createRow(2);
        HSSFCell celdaEtiquetaFCRruntimeNSProm=filaFCRuntimeNSPromedios.createCell(0);
        celdaEtiquetaFCRruntimeNSProm.setCellValue("FCMVR-VMR:Runtime[micros]");

        HSSFRow filaFCRecusionesPromedios = hojaPromedios.createRow(3);
        HSSFCell celdaEtiquetaFCRecurProm=filaFCRecusionesPromedios.createCell(0);
        celdaEtiquetaFCRecurProm.setCellValue("FCMVR-VMR:Recusiones");

        HSSFRow filaFCBackTracksPromedios = hojaPromedios.createRow(4);
        HSSFCell celdaEtiquetaFCBackTracksProm=filaFCBackTracksPromedios.createCell(0);
        celdaEtiquetaFCBackTracksProm.setCellValue("FCMVR-VMR:BackTracks");

        //FC Sin Heuristicas
        HSSFRow filaFCSHRuntimePromedios = hojaPromedios.createRow(5);
        HSSFCell celdaEtiquetaFCSHRruntimeProm=filaFCSHRuntimePromedios.createCell(0);
        celdaEtiquetaFCSHRruntimeProm.setCellValue("FCSinHeu:Runtime[ms]");

        HSSFRow filaFCSHRuntimeNSPromedios = hojaPromedios.createRow(6);
        HSSFCell celdaEtiquetaFCSHRruntimeNSProm=filaFCSHRuntimeNSPromedios.createCell(0);
        celdaEtiquetaFCSHRruntimeNSProm.setCellValue("FCSinHeu:Runtime[micros]");

        HSSFRow filaFCSHRecusionesPromedios = hojaPromedios.createRow(7);
        HSSFCell celdaEtiquetaFCSHRecurProm=filaFCSHRecusionesPromedios.createCell(0);
        celdaEtiquetaFCSHRecurProm.setCellValue("FCSinHeu:Recusiones");

        HSSFRow filaFCSHBackTracksPromedios = hojaPromedios.createRow(8);
        HSSFCell celdaEtiquetaFCSHBackTracksProm=filaFCSHBackTracksPromedios.createCell(0);
        celdaEtiquetaFCSHBackTracksProm.setCellValue("FCSinHeu:BackTracks");


        HSSFRow filaACRuntimePromedios = hojaPromedios.createRow(9);
        HSSFCell celdaEtiquetaACRruntimeProm=filaACRuntimePromedios.createCell(0);
        celdaEtiquetaACRruntimeProm.setCellValue("ACMVR-VMR:Runtime[ms]");

        HSSFRow filaACRuntimeNSPromedios = hojaPromedios.createRow(10);
        HSSFCell celdaEtiquetaACRruntimeNSProm=filaACRuntimeNSPromedios.createCell(0);
        celdaEtiquetaACRruntimeNSProm.setCellValue("ACMVR-VMR:Runtime[micros]");

        HSSFRow filaACRecusionesPromedios = hojaPromedios.createRow(11);
        HSSFCell celdaEtiquetaACRecurProm=filaACRecusionesPromedios.createCell(0);
        celdaEtiquetaACRecurProm.setCellValue("ACMVR-VMR:Recursiones");

        HSSFRow filaACBackTracksPromedios = hojaPromedios.createRow(12);
        HSSFCell celdaEtiquetaACBackTracksProm=filaACBackTracksPromedios.createCell(0);
        celdaEtiquetaACBackTracksProm.setCellValue("ACMVR-VMR:BaclTracks");


            HSSFRow filaACSHRuntimePromedios = hojaPromedios.createRow(13);
        HSSFCell celdaEtiquetaACSHRruntimeProm=filaACSHRuntimePromedios.createCell(0);
        celdaEtiquetaACSHRruntimeProm.setCellValue("ACSinHeu:Runtime[ms]");

        HSSFRow filaACSHRuntimeNSPromedios = hojaPromedios.createRow(14);
        HSSFCell celdaEtiquetaACSHRruntimeNSProm=filaACSHRuntimeNSPromedios.createCell(0);
        celdaEtiquetaACSHRruntimeNSProm.setCellValue("ACSinHeu:Runtime[micros]");

        HSSFRow filaACSHRecusionesPromedios = hojaPromedios.createRow(15);
        HSSFCell celdaEtiquetaACSHRecurProm=filaACSHRecusionesPromedios.createCell(0);
        celdaEtiquetaACSHRecurProm.setCellValue("ACSinHeu:Recursiones");

        HSSFRow filaACSHBackTracksPromedios = hojaPromedios.createRow(16);
        HSSFCell celdaEtiquetaACSHBackTracksProm=filaACSHBackTracksPromedios.createCell(0);
        celdaEtiquetaACSHBackTracksProm.setCellValue("ACSinHeu:BaclTracks");

        //Pagina de datos completos
        HSSFSheet hojaCompleta = libro.createSheet("Todos los datos");
        HSSFRow filaEncabezadoCompleta = hojaCompleta.createRow(0);
        HSSFCell celdaEncabezadoComp=filaEncabezadoCompleta.createCell(0);
        celdaEncabezadoComp.setCellValue("Algortimo/Problema");
        //Creo las filas de los datos
        HSSFRow filaFCRuntimeCompleta = hojaCompleta.createRow(1);
        HSSFCell celdaEtiquetaFCRruntimeComp=filaFCRuntimeCompleta.createCell(0);
        celdaEtiquetaFCRruntimeComp.setCellValue("FCMVR-VMR:Runtime[ms]");

        HSSFRow filaFCRuntimeNSCompleta = hojaCompleta.createRow(2);
        HSSFCell celdaEtiquetaFCRruntimeNSComp=filaFCRuntimeNSCompleta.createCell(0);
        celdaEtiquetaFCRruntimeNSComp.setCellValue("FCMVR-VMR:Runtime[micros]");

        HSSFRow filaFCRecusionesCompleta = hojaCompleta.createRow(3);
        HSSFCell celdaEtiquetaFCRecurComp=filaFCRecusionesCompleta.createCell(0);
        celdaEtiquetaFCRecurComp.setCellValue("FCMVR-VMR:Recusiones");

        HSSFRow filaFCBackTracksCompleta = hojaCompleta.createRow(4);
        HSSFCell celdaEtiquetaFCBackTracksComp=filaFCBackTracksCompleta.createCell(0);
        celdaEtiquetaFCBackTracksComp.setCellValue("FCMVR-VMR:BackTracks");
        //Sin Heuristica


        HSSFRow filaFCSHRuntimeCompleta = hojaCompleta.createRow(5);
        HSSFCell celdaEtiquetaFCSHRruntimeComp=filaFCSHRuntimeCompleta.createCell(0);
        celdaEtiquetaFCSHRruntimeComp.setCellValue("FCSinHeu:Runtime[ms]");

        HSSFRow filaFCSHRuntimeNSCompleta = hojaCompleta.createRow(6);
        HSSFCell celdaEtiquetaFCSHRruntimeNSComp=filaFCSHRuntimeNSCompleta.createCell(0);
        celdaEtiquetaFCSHRruntimeNSComp.setCellValue("FCSinHeu:Runtime[micros]");

        HSSFRow filaFCSHRecusionesCompleta = hojaCompleta.createRow(7);
        HSSFCell celdaEtiquetaFCSHRecurComp=filaFCSHRecusionesCompleta.createCell(0);
        celdaEtiquetaFCSHRecurComp.setCellValue("FCSinHeu:Recusiones");

        HSSFRow filaFCSHBackTracksCompleta = hojaCompleta.createRow(8);
        HSSFCell celdaEtiquetaFCSHBackTracksComp=filaFCSHBackTracksCompleta.createCell(0);
        celdaEtiquetaFCSHBackTracksComp.setCellValue("FCSinHeu:BackTracks");


        HSSFRow filaACRuntimeCompleta = hojaCompleta.createRow(9);
        HSSFCell celdaEtiquetaACRruntimeComp=filaACRuntimeCompleta.createCell(0);
        celdaEtiquetaACRruntimeComp.setCellValue("ACMVR-VMR:Runtime[ms]");

        HSSFRow filaACRuntimeNSCompleta = hojaCompleta.createRow(10);
        HSSFCell celdaEtiquetaACRruntimeNSComp=filaACRuntimeNSCompleta.createCell(0);
        celdaEtiquetaACRruntimeNSComp.setCellValue("ACMVR-VMR:Runtime[micros]");

        HSSFRow filaACRecusionesCompleta = hojaCompleta.createRow(11);
        HSSFCell celdaEtiquetaACRecurComp=filaACRecusionesCompleta.createCell(0);
        celdaEtiquetaACRecurComp.setCellValue("ACMVR-VMR:Recursiones");

        HSSFRow filaACBackTracksCompleta = hojaCompleta.createRow(12);
        HSSFCell celdaEtiquetaACBackTracksComp=filaACBackTracksCompleta.createCell(0);
        celdaEtiquetaACBackTracksComp.setCellValue("ACMVR-VMR:BaclTracks");

        //Sin Heuristicas
        HSSFRow filaACSHRuntimeCompleta = hojaCompleta.createRow(13);
        HSSFCell celdaEtiquetaACSHRruntimeComp=filaACSHRuntimeCompleta.createCell(0);
        celdaEtiquetaACSHRruntimeComp.setCellValue("ACSinHeu :Runtime[ms]");

        HSSFRow filaACSHRuntimeNSCompleta = hojaCompleta.createRow(14);
        HSSFCell celdaEtiquetaACSHRruntimeNSComp=filaACSHRuntimeNSCompleta.createCell(0);
        celdaEtiquetaACSHRruntimeNSComp.setCellValue("ACSinHeu :Runtime[micros]");

        HSSFRow filaACSHRecusionesCompleta = hojaCompleta.createRow(15);
        HSSFCell celdaEtiquetaACSHRecurComp=filaACSHRecusionesCompleta.createCell(0);
        celdaEtiquetaACSHRecurComp.setCellValue("ACSinHeu :Recursiones");

        HSSFRow filaACSHBackTracksCompleta = hojaCompleta.createRow(16);
        HSSFCell celdaEtiquetaACSHBackTracksComp=filaACSHBackTracksCompleta.createCell(0);
        celdaEtiquetaACSHBackTracksComp.setCellValue("ACSinHeu :BaclTracks");


        //Experimentacion
        GeneradorProblemas generador=new GeneradorProblemas();
        ProblemaAntenas problemaFC,problemaAC,problemaFCSH,problemaACSH;

        HeuristicaValor heuValor=new VMR();
        HeuristicaVariable heuVar=new MVR();
        HeuristicaValor heuValorSimple=new HeuValSimple();
        HeuristicaVariable heuVarSimple=new HeuVarSimple();
        ForwardChecking FC=new ForwardChecking(heuValor,heuVar);
        ArcoConsistencia AC=new ArcoConsistencia(heuValor,heuVar);
        ForwardChecking FCSH=new ForwardChecking(heuValorSimple,heuVarSimple);
        ArcoConsistencia ACSH=new ArcoConsistencia(heuValorSimple,heuVarSimple);

        boolean aux;

        int[] fzDistintas={6,8,10}; //frecuencias distintas
        double[] potMax={20.0,30.0,40.0};
        double[] fzsMax={10.0,20.0,30.0,40.0};

        //Variables auxiliares para los promedios
        //Sumas
        double sumaRunTFC = 0.0,sumaRTAC = 0.0,sumaRunTNSFC = 0.0,sumaRTNSAC = 0.0,sumaRecFC = 0.0,sumaRecAC = 0.0,sumaBackFC = 0.0,
                sumaBackAC = 0.0;
        //Sin Heuristicas
        double sumaRunTFCSH = 0.0,sumaRTACSH = 0.0,sumaRunTNSFCSH = 0.0,sumaRTNSACSH = 0.0,sumaRecFCSH = 0.0,sumaRecACSH = 0.0,
                sumaBackFCSH = 0.0,
                sumaBackACSH = 0.0;
        //Cuentas
        long totalRunTFC = 0,totalRTAC = 0,totalRunTNSFC = 0,totalRTNSAC = 0,totalRecFC = 0,totalRecAC = 0,totalBackFC = 0,totalBackAC = 0;

        long totalRunTFCSH = 0,totalRTACSH = 0,totalRunTNSFCSH = 0,totalRTNSACSH = 0,totalRecFCSH = 0,totalRecACSH = 0,
                totalBackFCSH = 0,totalBackACSH = 0;

        Random r=new Random(System.currentTimeMillis());

        //Para probleams de 4 antenas
        for (int i = 0; i < cantProblemasPorN; i++) {
            //Generar los problemas
            generador.generarProblema(4, 4,
                    fzDistintas[r.nextInt(fzDistintas.length)],
                    potMax[(i % potMax.length)],
                    fzsMax[(i % fzsMax.length)]);
            //Cargarlos en las variables problema
            problemaFC = generador.getP1();
            problemaAC = generador.getP2();
            problemaFCSH = generador.getP3();
            problemaACSH = generador.getP4();

            //Mostrar el problema previo solucion FC
            System.out.println("\n#-------------------------------------------------\n"
                    +problemaFC.imprimirProblema());
            //Resolver por FC
            aux = FC.resolver(problemaFC);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFC+=FC.getMedidasRendimiento().getRuntime();
            totalRunTFC++;
            sumaRunTNSFC+=FC.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFC++;
            sumaRecFC+=FC.getMedidasRendimiento().getRecursiones();
            totalRecFC++;
            sumaBackFC+=FC.getMedidasRendimiento().getBackTracks();
            totalBackFC++;


            filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntime());
            filaFCRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntimeNS());
            filaFCRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRecursiones());
            filaFCBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC DIO:" + aux);
            System.out.println("" + problemaFC.imprimirProblema());
            System.out.println("" + FC.getMedidasRendimiento().getReporte());

            //Resolver por FC Sin Heurtisitcas
            aux = FCSH.resolver(problemaFCSH);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFCSH+=FCSH.getMedidasRendimiento().getRuntime();
            totalRunTFCSH++;
            sumaRunTNSFCSH+=FCSH.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFCSH++;
            sumaRecFCSH+=FCSH.getMedidasRendimiento().getRecursiones();
            totalRecFCSH++;
            sumaBackFCSH+=FCSH.getMedidasRendimiento().getBackTracks();
            totalBackFCSH++;


            //filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntime());
            filaFCSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntimeNS());
            filaFCSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRecursiones());
            filaFCSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaFCSH.imprimirProblema());
            System.out.println("" + FCSH.getMedidasRendimiento().getReporte());
            
            //Resolver por AC
            aux = AC.resolver(problemaAC);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTAC+=AC.getMedidasRendimiento().getRuntime();
            totalRTAC++;
            sumaRTNSAC+=AC.getMedidasRendimiento().getRuntimeNS();
            totalRTNSAC++;
            sumaRecAC+=AC.getMedidasRendimiento().getRecursiones();
            totalRecAC++;
            sumaBackAC+=AC.getMedidasRendimiento().getBackTracks();
            totalBackAC++;

            filaACRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntime());
            filaACRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntimeNS());
            filaACRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRecursiones());
            filaACBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC DIO:" + aux);
            System.out.println("" + problemaAC.imprimirProblema());
            System.out.println("" + AC.getMedidasRendimiento().getReporte());

             //Resolver por AC Sin Heuristicas
            aux = ACSH.resolver(problemaACSH);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTACSH+=ACSH.getMedidasRendimiento().getRuntime();
            totalRTACSH++;
            sumaRTNSACSH+=ACSH.getMedidasRendimiento().getRuntimeNS();
            totalRTNSACSH++;
            sumaRecACSH+=ACSH.getMedidasRendimiento().getRecursiones();
            totalRecACSH++;
            sumaBackACSH+=ACSH.getMedidasRendimiento().getBackTracks();
            totalBackACSH++;

            filaACSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntime());
            filaACSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntimeNS());
            filaACSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRecursiones());
            filaACSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaACSH.imprimirProblema());
            System.out.println("" + ACSH.getMedidasRendimiento().getReporte());

            indiceColumnasCompletos++;
        }

        //Para probleams de 6 antenas
        for (int i = 0; i < cantProblemasPorN; i++) {
            //Generar los problemas
            generador.generarProblema(6, 6,
                    fzDistintas[r.nextInt(fzDistintas.length)],
                    potMax[(i % potMax.length)],
                    fzsMax[(i % fzsMax.length)]);
            //Cargarlos en las variables problema
            problemaFC = generador.getP1();
            problemaAC = generador.getP2();
            problemaFCSH = generador.getP3();
            problemaACSH = generador.getP4();

            //Mostrar el problema previo solucion FC
            System.out.println("\n#-----------------------------------\n"+problemaFC.imprimirProblema());
            //Resolver por FC
            aux = FC.resolver(problemaFC);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFC+=FC.getMedidasRendimiento().getRuntime();
            totalRunTFC++;
            sumaRunTNSFC+=FC.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFC++;
            sumaRecFC+=FC.getMedidasRendimiento().getRecursiones();
            totalRecFC++;
            sumaBackFC+=FC.getMedidasRendimiento().getBackTracks();
            totalBackFC++;


            filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntime());
            filaFCRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntimeNS());
            filaFCRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRecursiones());
            filaFCBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC DIO:" + aux);
            System.out.println("" + problemaFC.imprimirProblema());
            System.out.println("" + FC.getMedidasRendimiento().getReporte());

            //Resolver por FC Sin Heurtisitcas
            aux = FCSH.resolver(problemaFCSH);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFCSH+=FCSH.getMedidasRendimiento().getRuntime();
            totalRunTFCSH++;
            sumaRunTNSFCSH+=FCSH.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFCSH++;
            sumaRecFCSH+=FCSH.getMedidasRendimiento().getRecursiones();
            totalRecFCSH++;
            sumaBackFCSH+=FCSH.getMedidasRendimiento().getBackTracks();
            totalBackFCSH++;


            //filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntime());
            filaFCSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntimeNS());
            filaFCSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRecursiones());
            filaFCSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaFCSH.imprimirProblema());
            System.out.println("" + FCSH.getMedidasRendimiento().getReporte());

            //Resolver por AC
            aux = AC.resolver(problemaAC);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTAC+=AC.getMedidasRendimiento().getRuntime();
            totalRTAC++;
            sumaRTNSAC+=AC.getMedidasRendimiento().getRuntimeNS();
            totalRTNSAC++;
            sumaRecAC+=AC.getMedidasRendimiento().getRecursiones();
            totalRecAC++;
            sumaBackAC+=AC.getMedidasRendimiento().getBackTracks();
            totalBackAC++;

            filaACRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntime());
            filaACRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntimeNS());
            filaACRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRecursiones());
            filaACBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC DIO:" + aux);
            System.out.println("" + problemaAC.imprimirProblema());
            System.out.println("" + AC.getMedidasRendimiento().getReporte());


             //Resolver por AC Sin Heuristicas
            aux = ACSH.resolver(problemaACSH);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTACSH+=ACSH.getMedidasRendimiento().getRuntime();
            totalRTACSH++;
            sumaRTNSACSH+=ACSH.getMedidasRendimiento().getRuntimeNS();
            totalRTNSACSH++;
            sumaRecACSH+=ACSH.getMedidasRendimiento().getRecursiones();
            totalRecACSH++;
            sumaBackACSH+=ACSH.getMedidasRendimiento().getBackTracks();
            totalBackACSH++;

            filaACSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntime());
            filaACSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntimeNS());
            filaACSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRecursiones());
            filaACSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaACSH.imprimirProblema());
            System.out.println("" + ACSH.getMedidasRendimiento().getReporte());


            indiceColumnasCompletos++;
        }

        //Para probleams de 8 antenas
        for (int i = 0; i < cantProblemasPorN; i++) {
            //Generar los problemas
            generador.generarProblema(8, 8,
                    fzDistintas[r.nextInt(fzDistintas.length)],
                    potMax[(i % potMax.length)],
                    fzsMax[(i % fzsMax.length)]);
            //Cargarlos en las variables problema
            problemaFC = generador.getP1();
            problemaAC = generador.getP2();
            problemaFCSH = generador.getP3();
            problemaACSH = generador.getP4();

            //Mostrar el problema previo solucion FC
            System.out.println("\n#---------------------------------------------------\n"
                    +problemaFC.imprimirProblema());
            //Resolver por FC
            aux = FC.resolver(problemaFC);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFC+=FC.getMedidasRendimiento().getRuntime();
            totalRunTFC++;
            sumaRunTNSFC+=FC.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFC++;
            sumaRecFC+=FC.getMedidasRendimiento().getRecursiones();
            totalRecFC++;
            sumaBackFC+=FC.getMedidasRendimiento().getBackTracks();
            totalBackFC++;

            filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            
            filaFCRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntime());
            filaFCRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntimeNS());
            filaFCRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRecursiones());
            filaFCBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC DIO:" + aux);
            System.out.println("" + problemaFC.imprimirProblema());
            System.out.println("" + FC.getMedidasRendimiento().getReporte());

            //Resolver por FC Sin Heurtisitcas
            aux = FCSH.resolver(problemaFCSH);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFCSH+=FCSH.getMedidasRendimiento().getRuntime();
            totalRunTFCSH++;
            sumaRunTNSFCSH+=FCSH.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFCSH++;
            sumaRecFCSH+=FCSH.getMedidasRendimiento().getRecursiones();
            totalRecFCSH++;
            sumaBackFCSH+=FCSH.getMedidasRendimiento().getBackTracks();
            totalBackFCSH++;


            //filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntime());
            filaFCSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntimeNS());
            filaFCSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRecursiones());
            filaFCSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaFCSH.imprimirProblema());
            System.out.println("" + FCSH.getMedidasRendimiento().getReporte());


            //Resolver por AC
            aux = AC.resolver(problemaAC);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTAC+=AC.getMedidasRendimiento().getRuntime();
            totalRTAC++;
            sumaRTNSAC+=AC.getMedidasRendimiento().getRuntimeNS();
            totalRTNSAC++;
            sumaRecAC+=AC.getMedidasRendimiento().getRecursiones();
            totalRecAC++;
            sumaBackAC+=AC.getMedidasRendimiento().getBackTracks();
            totalBackAC++;

            filaACRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntime());
            filaACRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntimeNS());
            filaACRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRecursiones());
            filaACBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC DIO:" + aux);
            System.out.println("" + problemaAC.imprimirProblema());
            System.out.println("" + AC.getMedidasRendimiento().getReporte());


             //Resolver por AC Sin Heuristicas
            aux = ACSH.resolver(problemaACSH);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTACSH+=ACSH.getMedidasRendimiento().getRuntime();
            totalRTACSH++;
            sumaRTNSACSH+=ACSH.getMedidasRendimiento().getRuntimeNS();
            totalRTNSACSH++;
            sumaRecACSH+=ACSH.getMedidasRendimiento().getRecursiones();
            totalRecACSH++;
            sumaBackACSH+=ACSH.getMedidasRendimiento().getBackTracks();
            totalBackACSH++;

            filaACSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntime());
            filaACSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntimeNS());
            filaACSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRecursiones());
            filaACSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaACSH.imprimirProblema());
            System.out.println("" + ACSH.getMedidasRendimiento().getReporte());

            indiceColumnasCompletos++;
        }




        //Escribir los promedios
        //Promedio de RT FC
        double promRTFC=(sumaRunTFC)/(totalRunTFC);
        HSSFCell celdaDatosRTFCProm=filaFCRuntimePromedios.createCell(1);
        celdaDatosRTFCProm.setCellValue(promRTFC);
        //RT FC SH
        double promRTFCSH=(sumaRunTFCSH)/(totalRunTFCSH);
        HSSFCell celdaDatosRTFCSHProm=filaFCSHRuntimePromedios.createCell(1);
        celdaDatosRTFCSHProm.setCellValue(promRTFCSH);
        //RT NS FC
        double promRTNSFC=(sumaRunTNSFC)/(totalRunTNSFC);
        HSSFCell celdaDatosRTNSFCProm=filaFCRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSFCProm.setCellValue(promRTNSFC);
        //RT NS FC SH
        double promRTNSFCSH=(sumaRunTNSFCSH)/(totalRunTNSFCSH);
        HSSFCell celdaDatosRTNSFCSHProm=filaFCSHRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSFCSHProm.setCellValue(promRTNSFCSH);
        //Rec FC
        double promRecFC=(sumaRecFC)/(totalRecFC);
        HSSFCell celdaDatosRecFCProm=filaFCRecusionesPromedios.createCell(1);
        celdaDatosRecFCProm.setCellValue(promRecFC);

        //Rec FC SH
        double promRecFCSH=(sumaRecFCSH)/(totalRecFCSH);
        HSSFCell celdaDatosRecFCSHProm=filaFCSHRecusionesPromedios.createCell(1);
        celdaDatosRecFCSHProm.setCellValue(promRecFCSH);
        //BackFC
        double promBackFC=(sumaBackFC)/(totalBackFC);
        HSSFCell celdaDatosBackFCProm=filaFCBackTracksPromedios.createCell(1);
        celdaDatosBackFCProm.setCellValue(promBackFC);

        //BackFC SH
        double promBackFCSH=(sumaBackFCSH)/(totalBackFCSH);
        HSSFCell celdaDatosBackFCSHProm=filaFCSHBackTracksPromedios.createCell(1);
        celdaDatosBackFCSHProm.setCellValue(promBackFCSH);
        //RT AC
        double promRTAC=(sumaRTAC)/(totalRTAC);
        HSSFCell celdaDatosRTACProm=filaACRuntimePromedios.createCell(1);
        celdaDatosRTACProm.setCellValue(promRTAC);

        //RT AC SH
        double promRTACSH=(sumaRTACSH)/(totalRTACSH);
        HSSFCell celdaDatosRTACSHProm=filaACSHRuntimePromedios.createCell(1);
        celdaDatosRTACSHProm.setCellValue(promRTACSH);
        //RT NS AC
        double promRTNSAC=(sumaRTNSAC)/(totalRTNSAC);
        HSSFCell celdaDatosRTNSACProm=filaACRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSACProm.setCellValue(promRTNSAC);

        //RT NS AC SH
        double promRTNSACSH=(sumaRTNSACSH)/(totalRTNSACSH);
        HSSFCell celdaDatosRTNSACSHProm=filaACSHRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSACSHProm.setCellValue(promRTNSACSH);
        //Rec AC
        double promRecAC=(sumaRecAC)/(totalRecAC);
        HSSFCell celdaDatosRecACProm=filaACRecusionesPromedios.createCell(1);
        celdaDatosRecACProm.setCellValue(promRecAC);

        //Rec AC SH
        double promRecACSH=(sumaRecACSH)/(totalRecACSH);
        HSSFCell celdaDatosRecACSHProm=filaACSHRecusionesPromedios.createCell(1);
        celdaDatosRecACSHProm.setCellValue(promRecACSH);
        //Back AC
        double promBackAC=(sumaBackAC)/(totalBackAC);
        HSSFCell celdaDatosBackACProm=filaACBackTracksPromedios.createCell(1);
        celdaDatosBackACProm.setCellValue(promBackAC);

        //Back AC SH
        double promBackACSH=(sumaBackACSH)/(totalBackACSH);
        HSSFCell celdaDatosBackACSHProm=filaACSHBackTracksPromedios.createCell(1);
        celdaDatosBackACSHProm.setCellValue(promBackACSH);


        //Guardar los datos a un arhivo
        String strNombreArchivo = "Experimentacion.xls";
        File objFile = new File(strNombreArchivo);
        FileOutputStream archivoSalida = null;
        try {
            archivoSalida = new FileOutputStream(objFile);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Experimentador.class.getName()).log(Level.SEVERE, null, ex);
        }
            try {
                libro.write(archivoSalida);
                 archivoSalida.close();
            } catch (IOException ex) {
                Logger.getLogger(Experimentador.class.getName()).log(Level.SEVERE, null, ex);
            }
       
    }

    public void generarExperimentacion(int cantProblemasPorN,int cantVar){

        int indiceColumnasCompletos=1;

        //Exportación a excel
        //libro completo
        HSSFWorkbook libro=new HSSFWorkbook();
        //Pagina de promedios
        HSSFSheet hojaPromedios = libro.createSheet("Promedios");
        HSSFRow filaEncabezadoPromedios = hojaPromedios.createRow(0);
        HSSFCell celdaEncabezadoProm=filaEncabezadoPromedios.createCell(0);
        celdaEncabezadoProm.setCellValue("Algortimo/Problema");
        //Creo las filas de los datos
        HSSFRow filaFCRuntimePromedios = hojaPromedios.createRow(1);
        HSSFCell celdaEtiquetaFCRruntimeProm=filaFCRuntimePromedios.createCell(0);
        celdaEtiquetaFCRruntimeProm.setCellValue("FCMVR-VMR:Runtime[ms]");

        HSSFRow filaFCRuntimeNSPromedios = hojaPromedios.createRow(2);
        HSSFCell celdaEtiquetaFCRruntimeNSProm=filaFCRuntimeNSPromedios.createCell(0);
        celdaEtiquetaFCRruntimeNSProm.setCellValue("FCMVR-VMR:Runtime[micros]");

        HSSFRow filaFCRecusionesPromedios = hojaPromedios.createRow(3);
        HSSFCell celdaEtiquetaFCRecurProm=filaFCRecusionesPromedios.createCell(0);
        celdaEtiquetaFCRecurProm.setCellValue("FCMVR-VMR:Recusiones");

        HSSFRow filaFCBackTracksPromedios = hojaPromedios.createRow(4);
        HSSFCell celdaEtiquetaFCBackTracksProm=filaFCBackTracksPromedios.createCell(0);
        celdaEtiquetaFCBackTracksProm.setCellValue("FCMVR-VMR:BackTracks");

        //FC Sin Heuristicas
        HSSFRow filaFCSHRuntimePromedios = hojaPromedios.createRow(5);
        HSSFCell celdaEtiquetaFCSHRruntimeProm=filaFCSHRuntimePromedios.createCell(0);
        celdaEtiquetaFCSHRruntimeProm.setCellValue("FCSinHeu:Runtime[ms]");

        HSSFRow filaFCSHRuntimeNSPromedios = hojaPromedios.createRow(6);
        HSSFCell celdaEtiquetaFCSHRruntimeNSProm=filaFCSHRuntimeNSPromedios.createCell(0);
        celdaEtiquetaFCSHRruntimeNSProm.setCellValue("FCSinHeu:Runtime[micros]");

        HSSFRow filaFCSHRecusionesPromedios = hojaPromedios.createRow(7);
        HSSFCell celdaEtiquetaFCSHRecurProm=filaFCSHRecusionesPromedios.createCell(0);
        celdaEtiquetaFCSHRecurProm.setCellValue("FCSinHeu:Recusiones");

        HSSFRow filaFCSHBackTracksPromedios = hojaPromedios.createRow(8);
        HSSFCell celdaEtiquetaFCSHBackTracksProm=filaFCSHBackTracksPromedios.createCell(0);
        celdaEtiquetaFCSHBackTracksProm.setCellValue("FCSinHeu:BackTracks");


        HSSFRow filaACRuntimePromedios = hojaPromedios.createRow(9);
        HSSFCell celdaEtiquetaACRruntimeProm=filaACRuntimePromedios.createCell(0);
        celdaEtiquetaACRruntimeProm.setCellValue("ACMVR-VMR:Runtime[ms]");

        HSSFRow filaACRuntimeNSPromedios = hojaPromedios.createRow(10);
        HSSFCell celdaEtiquetaACRruntimeNSProm=filaACRuntimeNSPromedios.createCell(0);
        celdaEtiquetaACRruntimeNSProm.setCellValue("ACMVR-VMR:Runtime[micros]");

        HSSFRow filaACRecusionesPromedios = hojaPromedios.createRow(11);
        HSSFCell celdaEtiquetaACRecurProm=filaACRecusionesPromedios.createCell(0);
        celdaEtiquetaACRecurProm.setCellValue("ACMVR-VMR:Recursiones");

        HSSFRow filaACBackTracksPromedios = hojaPromedios.createRow(12);
        HSSFCell celdaEtiquetaACBackTracksProm=filaACBackTracksPromedios.createCell(0);
        celdaEtiquetaACBackTracksProm.setCellValue("ACMVR-VMR:BaclTracks");


            HSSFRow filaACSHRuntimePromedios = hojaPromedios.createRow(13);
        HSSFCell celdaEtiquetaACSHRruntimeProm=filaACSHRuntimePromedios.createCell(0);
        celdaEtiquetaACSHRruntimeProm.setCellValue("ACSinHeu:Runtime[ms]");

        HSSFRow filaACSHRuntimeNSPromedios = hojaPromedios.createRow(14);
        HSSFCell celdaEtiquetaACSHRruntimeNSProm=filaACSHRuntimeNSPromedios.createCell(0);
        celdaEtiquetaACSHRruntimeNSProm.setCellValue("ACSinHeu:Runtime[micros]");

        HSSFRow filaACSHRecusionesPromedios = hojaPromedios.createRow(15);
        HSSFCell celdaEtiquetaACSHRecurProm=filaACSHRecusionesPromedios.createCell(0);
        celdaEtiquetaACSHRecurProm.setCellValue("ACSinHeu:Recursiones");

        HSSFRow filaACSHBackTracksPromedios = hojaPromedios.createRow(16);
        HSSFCell celdaEtiquetaACSHBackTracksProm=filaACSHBackTracksPromedios.createCell(0);
        celdaEtiquetaACSHBackTracksProm.setCellValue("ACSinHeu:BaclTracks");

        HSSFRow filaBTRuntimePromedios = hojaPromedios.createRow(17);
        HSSFCell celdaEtiquetaBTRruntimeProm=filaBTRuntimePromedios.createCell(0);
        celdaEtiquetaBTRruntimeProm.setCellValue("BTMVR-VMR:Runtime[ms]");

        HSSFRow filaBTRuntimeNSPromedios = hojaPromedios.createRow(18);
        HSSFCell celdaEtiquetaBTRruntimeNSProm=filaBTRuntimeNSPromedios.createCell(0);
        celdaEtiquetaBTRruntimeNSProm.setCellValue("BTMVR-VMR:Runtime[micros]");

        HSSFRow filaBTRecusionesPromedios = hojaPromedios.createRow(19);
        HSSFCell celdaEtiquetaBTRecurProm=filaBTRecusionesPromedios.createCell(0);
        celdaEtiquetaBTRecurProm.setCellValue("BTMVR-VMR:Recursiones");

        HSSFRow filaBTBackTracksPromedios = hojaPromedios.createRow(20);
        HSSFCell celdaEtiquetaBTBackTracksProm=filaBTBackTracksPromedios.createCell(0);
        celdaEtiquetaBTBackTracksProm.setCellValue("BTMVR-VMR:BaclTracks");

         HSSFRow filaBTSHRuntimePromedios = hojaPromedios.createRow(21);
        HSSFCell celdaEtiquetaBTSHRruntimeProm=filaBTSHRuntimePromedios.createCell(0);
        celdaEtiquetaBTSHRruntimeProm.setCellValue("BTSinHeu:Runtime[ms]");

        HSSFRow filaBTSHRuntimeNSPromedios = hojaPromedios.createRow(22);
        HSSFCell celdaEtiquetaBTSHRruntimeNSProm=filaBTSHRuntimeNSPromedios.createCell(0);
        celdaEtiquetaBTSHRruntimeNSProm.setCellValue("BTSinHeu:Runtime[micros]");

        HSSFRow filaBTSHRecusionesPromedios = hojaPromedios.createRow(23);
        HSSFCell celdaEtiquetaBTSHRecurProm=filaBTSHRecusionesPromedios.createCell(0);
        celdaEtiquetaBTSHRecurProm.setCellValue("BTSinHeu:Recursiones");

        HSSFRow filaBTSHBackTracksPromedios = hojaPromedios.createRow(24);
        HSSFCell celdaEtiquetaBTSHBackTracksProm=filaBTSHBackTracksPromedios.createCell(0);
        celdaEtiquetaBTSHBackTracksProm.setCellValue("BTSinHeu:BaclTracks");


        //Pagina de datos completos
        HSSFSheet hojaCompleta = libro.createSheet("Todos los datos");
        HSSFRow filaEncabezadoCompleta = hojaCompleta.createRow(0);
        HSSFCell celdaEncabezadoComp=filaEncabezadoCompleta.createCell(0);
        celdaEncabezadoComp.setCellValue("Algortimo/Problema");
        //Creo las filas de los datos
        HSSFRow filaFCRuntimeCompleta = hojaCompleta.createRow(1);
        HSSFCell celdaEtiquetaFCRruntimeComp=filaFCRuntimeCompleta.createCell(0);
        celdaEtiquetaFCRruntimeComp.setCellValue("FCMVR-VMR:Runtime[ms]");

        HSSFRow filaFCRuntimeNSCompleta = hojaCompleta.createRow(2);
        HSSFCell celdaEtiquetaFCRruntimeNSComp=filaFCRuntimeNSCompleta.createCell(0);
        celdaEtiquetaFCRruntimeNSComp.setCellValue("FCMVR-VMR:Runtime[micros]");

        HSSFRow filaFCRecusionesCompleta = hojaCompleta.createRow(3);
        HSSFCell celdaEtiquetaFCRecurComp=filaFCRecusionesCompleta.createCell(0);
        celdaEtiquetaFCRecurComp.setCellValue("FCMVR-VMR:Recusiones");

        HSSFRow filaFCBackTracksCompleta = hojaCompleta.createRow(4);
        HSSFCell celdaEtiquetaFCBackTracksComp=filaFCBackTracksCompleta.createCell(0);
        celdaEtiquetaFCBackTracksComp.setCellValue("FCMVR-VMR:BackTracks");
        //Sin Heuristica


        HSSFRow filaFCSHRuntimeCompleta = hojaCompleta.createRow(5);
        HSSFCell celdaEtiquetaFCSHRruntimeComp=filaFCSHRuntimeCompleta.createCell(0);
        celdaEtiquetaFCSHRruntimeComp.setCellValue("FCSinHeu:Runtime[ms]");

        HSSFRow filaFCSHRuntimeNSCompleta = hojaCompleta.createRow(6);
        HSSFCell celdaEtiquetaFCSHRruntimeNSComp=filaFCSHRuntimeNSCompleta.createCell(0);
        celdaEtiquetaFCSHRruntimeNSComp.setCellValue("FCSinHeu:Runtime[micros]");

        HSSFRow filaFCSHRecusionesCompleta = hojaCompleta.createRow(7);
        HSSFCell celdaEtiquetaFCSHRecurComp=filaFCSHRecusionesCompleta.createCell(0);
        celdaEtiquetaFCSHRecurComp.setCellValue("FCSinHeu:Recusiones");

        HSSFRow filaFCSHBackTracksCompleta = hojaCompleta.createRow(8);
        HSSFCell celdaEtiquetaFCSHBackTracksComp=filaFCSHBackTracksCompleta.createCell(0);
        celdaEtiquetaFCSHBackTracksComp.setCellValue("FCSinHeu:BackTracks");


        HSSFRow filaACRuntimeCompleta = hojaCompleta.createRow(9);
        HSSFCell celdaEtiquetaACRruntimeComp=filaACRuntimeCompleta.createCell(0);
        celdaEtiquetaACRruntimeComp.setCellValue("ACMVR-VMR:Runtime[ms]");

        HSSFRow filaACRuntimeNSCompleta = hojaCompleta.createRow(10);
        HSSFCell celdaEtiquetaACRruntimeNSComp=filaACRuntimeNSCompleta.createCell(0);
        celdaEtiquetaACRruntimeNSComp.setCellValue("ACMVR-VMR:Runtime[micros]");

        HSSFRow filaACRecusionesCompleta = hojaCompleta.createRow(11);
        HSSFCell celdaEtiquetaACRecurComp=filaACRecusionesCompleta.createCell(0);
        celdaEtiquetaACRecurComp.setCellValue("ACMVR-VMR:Recursiones");

        HSSFRow filaACBackTracksCompleta = hojaCompleta.createRow(12);
        HSSFCell celdaEtiquetaACBackTracksComp=filaACBackTracksCompleta.createCell(0);
        celdaEtiquetaACBackTracksComp.setCellValue("ACMVR-VMR:BaclTracks");

        //Sin Heuristicas
        HSSFRow filaACSHRuntimeCompleta = hojaCompleta.createRow(13);
        HSSFCell celdaEtiquetaACSHRruntimeComp=filaACSHRuntimeCompleta.createCell(0);
        celdaEtiquetaACSHRruntimeComp.setCellValue("ACSinHeu :Runtime[ms]");

        HSSFRow filaACSHRuntimeNSCompleta = hojaCompleta.createRow(14);
        HSSFCell celdaEtiquetaACSHRruntimeNSComp=filaACSHRuntimeNSCompleta.createCell(0);
        celdaEtiquetaACSHRruntimeNSComp.setCellValue("ACSinHeu :Runtime[micros]");

        HSSFRow filaACSHRecusionesCompleta = hojaCompleta.createRow(15);
        HSSFCell celdaEtiquetaACSHRecurComp=filaACSHRecusionesCompleta.createCell(0);
        celdaEtiquetaACSHRecurComp.setCellValue("ACSinHeu :Recursiones");

        HSSFRow filaACSHBackTracksCompleta = hojaCompleta.createRow(16);
        HSSFCell celdaEtiquetaACSHBackTracksComp=filaACSHBackTracksCompleta.createCell(0);
        celdaEtiquetaACSHBackTracksComp.setCellValue("ACSinHeu :BaclTracks");

        //BackTracking simple

        HSSFRow filaBTRuntimeCompleta = hojaCompleta.createRow(17);
        HSSFCell celdaEtiquetaBTRruntimeComp=filaBTRuntimeCompleta.createCell(0);
        celdaEtiquetaBTRruntimeComp.setCellValue("BTMVR-VMR:Runtime[ms]");

        HSSFRow filaBTRuntimeNSCompleta = hojaCompleta.createRow(18);
        HSSFCell celdaEtiquetaBTRruntimeNSComp=filaBTRuntimeNSCompleta.createCell(0);
        celdaEtiquetaBTRruntimeNSComp.setCellValue("BTMVR-VMR:Runtime[micros]");

        HSSFRow filaBTRecusionesCompleta = hojaCompleta.createRow(19);
        HSSFCell celdaEtiquetaBTRecurComp=filaBTRecusionesCompleta.createCell(0);
        celdaEtiquetaBTRecurComp.setCellValue("BTMVR-VMR:Recursiones");

        HSSFRow filaBTBackTracksCompleta = hojaCompleta.createRow(20);
        HSSFCell celdaEtiquetaBTBackTracksComp=filaBTBackTracksCompleta.createCell(0);
        celdaEtiquetaBTBackTracksComp.setCellValue("BTMVR-VMR:BaclTracks");

        //Sin Heuristicas
        HSSFRow filaBTSHRuntimeCompleta = hojaCompleta.createRow(21);
        HSSFCell celdaEtiquetaBTSHRruntimeComp=filaBTSHRuntimeCompleta.createCell(0);
        celdaEtiquetaBTSHRruntimeComp.setCellValue("BTSinHeu :Runtime[ms]");

        HSSFRow filaBTSHRuntimeNSCompleta = hojaCompleta.createRow(22);
        HSSFCell celdaEtiquetaBTSHRruntimeNSComp=filaBTSHRuntimeNSCompleta.createCell(0);
        celdaEtiquetaBTSHRruntimeNSComp.setCellValue("BTSinHeu :Runtime[micros]");

        HSSFRow filaBTSHRecusionesCompleta = hojaCompleta.createRow(23);
        HSSFCell celdaEtiquetaBTSHRecurComp=filaBTSHRecusionesCompleta.createCell(0);
        celdaEtiquetaBTSHRecurComp.setCellValue("BTSinHeu :Recursiones");

        HSSFRow filaBTSHBackTracksCompleta = hojaCompleta.createRow(24);
        HSSFCell celdaEtiquetaBTSHBackTracksComp=filaBTSHBackTracksCompleta.createCell(0);
        celdaEtiquetaBTSHBackTracksComp.setCellValue("BTSinHeu :BaclTracks");



        //Experimentacion
        GeneradorProblemas generador=new GeneradorProblemas();
        ProblemaAntenas problemaBT,problemaBTSH,problemaFC,problemaAC,problemaFCSH,problemaACSH;

        HeuristicaValor heuValor=new VMR();
        HeuristicaVariable heuVar=new MVR();
        HeuristicaValor heuValorSimple=new HeuValSimple();
        HeuristicaVariable heuVarSimple=new HeuVarSimple();

        ForwardChecking FC=new ForwardChecking(heuValor,heuVar);
        ArcoConsistencia AC=new ArcoConsistencia(heuValor,heuVar);
        ForwardChecking FCSH=new ForwardChecking(heuValorSimple,heuVarSimple);
        ArcoConsistencia ACSH=new ArcoConsistencia(heuValorSimple,heuVarSimple);
        Backtracking BT=new Backtracking(heuValorSimple, heuVarSimple);
        Backtracking BTSH=new Backtracking(heuValor, heuVar);

        boolean aux;


       int[] fzDistintas={5,10,15}; //frecuencias distintas
       //Potencias
       double[] potMax={20.0,30.0,40.0};
       //Frecuencias en MHz
       double[] fzsMax={800.0,900.0,1000,1800};


        //Variables auxiliares para los promedios
        //Sumas
        double sumaRunTFC = 0.0,sumaRTAC = 0.0,sumaRunTNSFC = 0.0,sumaRTNSAC = 0.0,sumaRecFC = 0.0,sumaRecAC = 0.0,sumaBackFC = 0.0,
                sumaBackAC = 0.0, sumaRTBT=0.0,sumaRTNSBT=0.0,sumaRecBT=0.0,sumaBackBT=0.0;
        //Sin Heuristicas
        double sumaRunTFCSH = 0.0,sumaRTACSH = 0.0,sumaRunTNSFCSH = 0.0,sumaRTNSACSH = 0.0,sumaRecFCSH = 0.0,sumaRecACSH = 0.0,
                sumaBackFCSH = 0.0,
                sumaBackACSH = 0.0,sumaRTBTSH=0.0,sumaRTNSBTSH=0.0,sumaRecBTSH=0.0,sumaBackBTSH=0.0;
        //Cuentas
        long totalRunTFC = 0,totalRTAC = 0,totalRunTNSFC = 0,totalRTNSAC = 0,totalRecFC = 0,totalRecAC = 0,totalBackFC = 0,totalBackAC = 0
                ,totalRTBT=0,totalRTNSBT=0,totalRecBT=0,totalBackBT=0;

        long totalRunTFCSH = 0,totalRTACSH = 0,totalRunTNSFCSH = 0,totalRTNSACSH = 0,totalRecFCSH = 0,totalRecACSH = 0,
                totalBackFCSH = 0,totalBackACSH = 0,
                totalRTBTSH=0,totalRTNSBTSH=0,totalRecBTSH=0,totalBackBTSH=0;


        Random r=new Random(System.currentTimeMillis());

        //Para probleams de cantVar antenas
        for (int i = 0; i < cantProblemasPorN; i++) {
            //Generar los problemas
            System.out.println("\n#Iteracion nro:"+i);
            generador.generarProblema(cantVar, cantVar,
                    fzDistintas[r.nextInt(fzDistintas.length)],
                    potMax[(i % potMax.length)],
                    fzsMax[(i % fzsMax.length)]);
            //Cargarlos en las variables problema
            problemaFC = generador.getP1();
            problemaAC = generador.getP2();
            problemaFCSH = generador.getP3();
            problemaACSH = generador.getP4();
            problemaBT=generador.getP5();
            problemaBTSH=generador.getP6();

            //Mostrar el problema previo solucion FC
            System.out.println("\n#-------------------------------------------------\n"
                    +problemaFC.imprimirProblema());
            //Resolver por FC
            aux = FC.resolver(problemaFC);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFC+=FC.getMedidasRendimiento().getRuntime();
            totalRunTFC++;
            sumaRunTNSFC+=FC.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFC++;
            sumaRecFC+=FC.getMedidasRendimiento().getRecursiones();
            totalRecFC++;
            sumaBackFC+=FC.getMedidasRendimiento().getBackTracks();
            totalBackFC++;


            filaEncabezadoCompleta.createCell(indiceColumnasCompletos).setCellValue("n = "+problemaFC.getVariables().size());

            filaFCRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntime());
            filaFCRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRuntimeNS());
            filaFCRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getRecursiones());
            filaFCBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FC.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC DIO:" + aux);
            System.out.println("" + problemaFC.imprimirProblema());
            System.out.println("" + FC.getMedidasRendimiento().getReporte());

            //Resolver por FC Sin Heurtisitcas
            aux = FCSH.resolver(problemaFCSH);
            //Guardar resultados a el archivo
            //Suma parcial de medidas de rendimiento
            sumaRunTFCSH+=FCSH.getMedidasRendimiento().getRuntime();
            totalRunTFCSH++;
            sumaRunTNSFCSH+=FCSH.getMedidasRendimiento().getRuntimeNS();
            totalRunTNSFCSH++;
            sumaRecFCSH+=FCSH.getMedidasRendimiento().getRecursiones();
            totalRecFCSH++;
            sumaBackFCSH+=FCSH.getMedidasRendimiento().getBackTracks();
            totalBackFCSH++;


            filaFCSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntime());
            filaFCSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRuntimeNS());
            filaFCSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getRecursiones());
            filaFCSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(FCSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la Solución FC
            System.out.println("\n#LA RESOLUCION FC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaFCSH.imprimirProblema());
            System.out.println("" + FCSH.getMedidasRendimiento().getReporte());

            //Resolver por AC
            aux = AC.resolver(problemaAC);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTAC+=AC.getMedidasRendimiento().getRuntime();
            totalRTAC++;
            sumaRTNSAC+=AC.getMedidasRendimiento().getRuntimeNS();
            totalRTNSAC++;
            sumaRecAC+=AC.getMedidasRendimiento().getRecursiones();
            totalRecAC++;
            sumaBackAC+=AC.getMedidasRendimiento().getBackTracks();
            totalBackAC++;

            filaACRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntime());
            filaACRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRuntimeNS());
            filaACRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getRecursiones());
            filaACBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(AC.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC DIO:" + aux);
            System.out.println("" + problemaAC.imprimirProblema());
            System.out.println("" + AC.getMedidasRendimiento().getReporte());

             //Resolver por AC Sin Heuristicas
            aux = ACSH.resolver(problemaACSH);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTACSH+=ACSH.getMedidasRendimiento().getRuntime();
            totalRTACSH++;
            sumaRTNSACSH+=ACSH.getMedidasRendimiento().getRuntimeNS();
            totalRTNSACSH++;
            sumaRecACSH+=ACSH.getMedidasRendimiento().getRecursiones();
            totalRecACSH++;
            sumaBackACSH+=ACSH.getMedidasRendimiento().getBackTracks();
            totalBackACSH++;

            filaACSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntime());
            filaACSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRuntimeNS());
            filaACSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getRecursiones());
            filaACSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(ACSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION AC sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaACSH.imprimirProblema());
            System.out.println("" + ACSH.getMedidasRendimiento().getReporte());

            //Resolver por BackTracking simple

             //Resolver por BT
            aux = BT.resolver(problemaBT);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTBT+=BT.getMedidasRendimiento().getRuntime();
            totalRTBT++;
            sumaRTNSBT+=BT.getMedidasRendimiento().getRuntimeNS();
            totalRTNSBT++;
            sumaRecBT+=BT.getMedidasRendimiento().getRecursiones();
            totalRecBT++;
            sumaBackBT+=BT.getMedidasRendimiento().getBackTracks();
            totalBackBT++;

            filaBTRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(BT.getMedidasRendimiento().getRuntime());
            filaBTRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(BT.getMedidasRendimiento().getRuntimeNS());
            filaBTRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(BT.getMedidasRendimiento().getRecursiones());
            filaBTBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(BT.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por BT
            System.out.println("\n#LA RESOLUCION BT DIO:" + aux);
            System.out.println("" + problemaBT.imprimirProblema());
            System.out.println("" + BT.getMedidasRendimiento().getReporte());

             //Resolver por BT Sin Heuristicas
            aux = BTSH.resolver(problemaBTSH);
            //Guardar los resultados a el archivo

            //Suma parcial de medidas de rendimiento
            sumaRTBTSH+=BTSH.getMedidasRendimiento().getRuntime();
            totalRTBTSH++;
            sumaRTNSBTSH+=BTSH.getMedidasRendimiento().getRuntimeNS();
            totalRTNSBTSH++;
            sumaRecBTSH+=BTSH.getMedidasRendimiento().getRecursiones();
            totalRecBTSH++;
            sumaBackBTSH+=BTSH.getMedidasRendimiento().getBackTracks();
            totalBackBTSH++;

            filaBTSHRuntimeCompleta.createCell(indiceColumnasCompletos).setCellValue(BTSH.getMedidasRendimiento().getRuntime());
            filaBTSHRuntimeNSCompleta.createCell(indiceColumnasCompletos).setCellValue(BTSH.getMedidasRendimiento().getRuntimeNS());
            filaBTSHRecusionesCompleta.createCell(indiceColumnasCompletos).setCellValue(BTSH.getMedidasRendimiento().getRecursiones());
            filaBTSHBackTracksCompleta.createCell(indiceColumnasCompletos).setCellValue(BTSH.getMedidasRendimiento().getBackTracks());

            //Mostrar la solución por AC
            System.out.println("\n#LA RESOLUCION BT sin Heuristicas DIO:" + aux);
            System.out.println("" + problemaBTSH.imprimirProblema());
            System.out.println("" + BTSH.getMedidasRendimiento().getReporte());



            indiceColumnasCompletos++;
        }

        //Escribir los promedios
        //Promedio de RT FC
        double promRTFC=(sumaRunTFC)/(totalRunTFC);
        HSSFCell celdaDatosRTFCProm=filaFCRuntimePromedios.createCell(1);
        celdaDatosRTFCProm.setCellValue(promRTFC);
        //RT FC SH
        double promRTFCSH=(sumaRunTFCSH)/(totalRunTFCSH);
        HSSFCell celdaDatosRTFCSHProm=filaFCSHRuntimePromedios.createCell(1);
        celdaDatosRTFCSHProm.setCellValue(promRTFCSH);
        //RT NS FC
        double promRTNSFC=(sumaRunTNSFC)/(totalRunTNSFC);
        HSSFCell celdaDatosRTNSFCProm=filaFCRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSFCProm.setCellValue(promRTNSFC);
        //RT NS FC SH
        double promRTNSFCSH=(sumaRunTNSFCSH)/(totalRunTNSFCSH);
        HSSFCell celdaDatosRTNSFCSHProm=filaFCSHRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSFCSHProm.setCellValue(promRTNSFCSH);
        //Rec FC
        double promRecFC=(sumaRecFC)/(totalRecFC);
        HSSFCell celdaDatosRecFCProm=filaFCRecusionesPromedios.createCell(1);
        celdaDatosRecFCProm.setCellValue(promRecFC);

        //Rec FC SH
        double promRecFCSH=(sumaRecFCSH)/(totalRecFCSH);
        HSSFCell celdaDatosRecFCSHProm=filaFCSHRecusionesPromedios.createCell(1);
        celdaDatosRecFCSHProm.setCellValue(promRecFCSH);
        //BackFC
        double promBackFC=(sumaBackFC)/(totalBackFC);
        HSSFCell celdaDatosBackFCProm=filaFCBackTracksPromedios.createCell(1);
        celdaDatosBackFCProm.setCellValue(promBackFC);

        //BackFC SH
        double promBackFCSH=(sumaBackFCSH)/(totalBackFCSH);
        HSSFCell celdaDatosBackFCSHProm=filaFCSHBackTracksPromedios.createCell(1);
        celdaDatosBackFCSHProm.setCellValue(promBackFCSH);
        //RT AC
        double promRTAC=(sumaRTAC)/(totalRTAC);
        HSSFCell celdaDatosRTACProm=filaACRuntimePromedios.createCell(1);
        celdaDatosRTACProm.setCellValue(promRTAC);

        //RT AC SH
        double promRTACSH=(sumaRTACSH)/(totalRTACSH);
        HSSFCell celdaDatosRTACSHProm=filaACSHRuntimePromedios.createCell(1);
        celdaDatosRTACSHProm.setCellValue(promRTACSH);
        //RT NS AC
        double promRTNSAC=(sumaRTNSAC)/(totalRTNSAC);
        HSSFCell celdaDatosRTNSACProm=filaACRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSACProm.setCellValue(promRTNSAC);

        //RT NS AC SH
        double promRTNSACSH=(sumaRTNSACSH)/(totalRTNSACSH);
        HSSFCell celdaDatosRTNSACSHProm=filaACSHRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSACSHProm.setCellValue(promRTNSACSH);
        //Rec AC
        double promRecAC=(sumaRecAC)/(totalRecAC);
        HSSFCell celdaDatosRecACProm=filaACRecusionesPromedios.createCell(1);
        celdaDatosRecACProm.setCellValue(promRecAC);

        //Rec AC SH
        double promRecACSH=(sumaRecACSH)/(totalRecACSH);
        HSSFCell celdaDatosRecACSHProm=filaACSHRecusionesPromedios.createCell(1);
        celdaDatosRecACSHProm.setCellValue(promRecACSH);
        //Back AC
        double promBackAC=(sumaBackAC)/(totalBackAC);
        HSSFCell celdaDatosBackACProm=filaACBackTracksPromedios.createCell(1);
        celdaDatosBackACProm.setCellValue(promBackAC);

        //Back AC SH
        double promBackACSH=(sumaBackACSH)/(totalBackACSH);
        HSSFCell celdaDatosBackACSHProm=filaACSHBackTracksPromedios.createCell(1);
        celdaDatosBackACSHProm.setCellValue(promBackACSH);

        //BT
        //RT BT
        double promRTBT=(sumaRTBT)/(totalRTBT);
        HSSFCell celdaDatosRTBTProm=filaBTRuntimePromedios.createCell(1);
        celdaDatosRTBTProm.setCellValue(promRTBT);

        //RT AC SH
        double promRTBTSH=(sumaRTBTSH)/(totalRTBTSH);
        HSSFCell celdaDatosRTBTSHProm=filaBTSHRuntimePromedios.createCell(1);
        celdaDatosRTBTSHProm.setCellValue(promRTBTSH);
        //RT NS AC
        double promRTNSBT=(sumaRTNSBT)/(totalRTNSBT);
        HSSFCell celdaDatosRTNSBTProm=filaBTRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSBTProm.setCellValue(promRTNSBT);

        //RT NS AC SH
        double promRTNSBTSH=(sumaRTNSBTSH)/(totalRTNSBTSH);
        HSSFCell celdaDatosRTNSBTSHProm=filaBTSHRuntimeNSPromedios.createCell(1);
        celdaDatosRTNSBTSHProm.setCellValue(promRTNSBTSH);
        //Rec BT
        double promRecBT=(sumaRecBT)/(totalRecBT);
        HSSFCell celdaDatosRecBTProm=filaBTRecusionesPromedios.createCell(1);
        celdaDatosRecBTProm.setCellValue(promRecBT);

        //Rec BT SH
        double promRecBTSH=(sumaRecBTSH)/(totalRecBTSH);
        HSSFCell celdaDatosRecBTSHProm=filaBTSHRecusionesPromedios.createCell(1);
        celdaDatosRecBTSHProm.setCellValue(promRecBTSH);
        //Back AC
        double promBackBT=(sumaBackBT)/(totalBackBT);
        HSSFCell celdaDatosBackBTProm=filaBTBackTracksPromedios.createCell(1);
        celdaDatosBackBTProm.setCellValue(promBackBT);

        //Back AC SH
        double promBackBTSH=(sumaBackBTSH)/(totalBackBTSH);
        HSSFCell celdaDatosBackBTSHProm=filaBTSHBackTracksPromedios.createCell(1);
        celdaDatosBackBTSHProm.setCellValue(promBackBTSH);


        //Guardar los datos a un arhivo
        String strNombreArchivo = "Experimentacion_"+cantVar+"Var_"+cantProblemasPorN+"Corridas.xls";
        File objFile = new File(strNombreArchivo);
        FileOutputStream archivoSalida = null;
        try {
            archivoSalida = new FileOutputStream(objFile);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Experimentador.class.getName()).log(Level.SEVERE, null, ex);
        }
            try {
                libro.write(archivoSalida);
                 archivoSalida.close();
            } catch (IOException ex) {
                Logger.getLogger(Experimentador.class.getName()).log(Level.SEVERE, null, ex);
            }

    }

    }
